import { fourDotsSpinnerSvg } from '@/assets/svg/loading'
import { MenuListType } from '@/types/menu'
import { processRoute } from '@/utils/menu'
import { ElLoading, ElMessage } from 'element-plus'
import { asyncRoutes } from '@/router/modules/asyncRoutes' // 用作备份数据
import { RoutesAlias } from '@/router/modules/routesAlias'
import request from '@/Newapi/request/request'

// 菜单相关接口前缀
const API_PREFIX = '/static';

// 菜单接口路径
const MENU_API_ENDPOINT = '/system/menu/my';
// 菜单管理相关接口
const MENU_LIST_ENDPOINT = '/menu/list';       // 菜单列表查询接口
const MENU_ADD_ENDPOINT = '/menu/add';         // 添加菜单接口
const MENU_UPDATE_ENDPOINT = '/menu/update';   // 更新菜单接口
const MENU_DELETE_ENDPOINT = '/user/del';      // 批量删除接口

// 菜单接口
export const menuService = {
  // 获取菜单列表，从服务器API获取
  getMenuList(
    delay: number = 300
  ): Promise<{ menuList: MenuListType[]; closeLoading: () => void }> {
    // 显示加载动画
    const loading = ElLoading.service({
      lock: true,
      background: 'rgba(0, 0, 0, 0)',
      svg: fourDotsSpinnerSvg,
      svgViewBox: '0 0 40 40'
    });

    // 设置超时，确保loading不会一直显示
    const loadingTimer = setTimeout(() => {
      loading.close();
    }, 10000);

    // 完整的API URL
    const menuApiUrl = `${API_PREFIX}${MENU_API_ENDPOINT}`;
    console.log('请求菜单数据，URL:', menuApiUrl);

    // 创建Promise处理菜单获取逻辑
    return new Promise((resolve) => {
      // 检查用户是否已登录
      const token = localStorage.getItem('token');
      const isLoggedIn = !!token;
      
      // 未登录时，直接使用默认菜单，不发送请求
      if (!isLoggedIn) {
        console.log('用户未登录，使用默认菜单');
        const processedMenuList = asyncRoutes.map(route => processRoute(route));
        clearTimeout(loadingTimer);
        
        resolve({
          menuList: processedMenuList,
          closeLoading: () => loading.close()
        });
        return;
      }
      
      // 用户已登录，从后端API获取菜单数据
      request.get(menuApiUrl)
        .then(response => {
          // 检查API响应结构
          if (!response || !Array.isArray(response.data)) {
            console.warn('菜单API返回格式不符合预期，使用默认菜单:', response);
            throw new Error('API响应格式错误');
          }
          
          // 处理API返回的菜单数据
          const menuData = this.processApiResponseData(response.data);
          const processedMenuList = menuData.map((route: any) => processRoute(route));
          
          clearTimeout(loadingTimer);
          console.log('成功获取菜单数据，菜单数量:', processedMenuList.length);
          
          // 返回处理后的菜单数据和关闭加载动画的函数
        resolve({
          menuList: processedMenuList,
          closeLoading: () => loading.close()
          });
        })
        .catch(error => {
          // 记录错误
          console.error('获取菜单数据失败，使用默认菜单:', error);
          
          // 使用备用菜单数据
          const processedMenuList = asyncRoutes.map(route => processRoute(route));
          clearTimeout(loadingTimer);
          
          // 显示错误提示
          ElMessage.warning({
            message: '获取菜单失败，使用默认菜单',
            type: 'warning',
            duration: 3000
          });
          
          // 返回备用菜单数据
          resolve({
            menuList: processedMenuList,
            closeLoading: () => loading.close()
          });
        });
    });
  },

  // 获取菜单管理列表数据
  async getMenuListForManagement(): Promise<any[]> {
    try {
      console.log('API: 请求菜单管理列表');
      
      const response = await request.get(`${API_PREFIX}${MENU_LIST_ENDPOINT}`);
      console.log('API: 菜单列表接口原始响应:', response);
      
      // 检查响应结构
      if (response) {
        // 检查常见的数据格式
        // 直接返回数组
        if (Array.isArray(response.data)) {
          console.log('API: 获取菜单管理列表成功 (直接数组), 数量:', response.data.length);
          return response.data;
        }
        // 格式: { data: { rows: [...] } }
        else if (response.data && Array.isArray(response.data.rows)) {
          console.log('API: 获取菜单管理列表成功 (rows格式), 数量:', response.data.rows.length);
          return response.data.rows;
        }
        // 格式: { data: { list: [...] } }
        else if (response.data && Array.isArray(response.data.list)) {
          console.log('API: 获取菜单管理列表成功 (list格式), 数量:', response.data.list.length);
          return response.data.list;
        }
        // 格式: { data: [...] }
        else if (response.data && Array.isArray(response.data)) {
          console.log('API: 获取菜单管理列表成功, 数量:', response.data.length);
          return response.data;
        }
        // 不支持的格式，但有返回数据
        else {
          console.warn('API: 菜单列表数据格式不符合预期:', response.data);
          if (response.data && typeof response.data === 'object') {
            // 尝试将对象转为数组
            const dataArray = Object.values(response.data).filter(item => typeof item === 'object');
            if (dataArray.length > 0) {
              console.log('API: 尝试将数据转换为数组格式，数量:', dataArray.length);
              return dataArray;
            }
          }
          
          // 无法处理的格式，返回空数组
          ElMessage.warning('菜单数据格式异常，请联系管理员');
          return [];
        }
      } else {
        // 响应格式异常
        console.error('API: 菜单列表接口响应格式异常:', response);
        ElMessage.error('获取菜单列表失败，响应格式异常');
        return [];
      }
    } catch (error) {
      // 网络错误或其他异常
      console.error('API: 获取菜单管理列表请求失败:', error);
      ElMessage.error('获取菜单列表失败，请检查网络连接');
      return [];
    }
  },

  // 添加菜单
  async addMenu(menuData: any): Promise<any> {
    try {
      console.log('添加菜单，参数:', menuData);
      
      const response = await request.post(`${API_PREFIX}${MENU_ADD_ENDPOINT}`, menuData);
      
      if (response) {
        console.log('添加菜单成功:', response);
        ElMessage.success('添加菜单成功');
        return response.data;
      } else {
        console.error('添加菜单失败:', response);
        ElMessage.error('添加菜单失败');
        throw new Error('添加菜单接口返回异常');
      }
    } catch (error: any) {
      console.error('添加菜单请求失败:', error);
      ElMessage.error(error.message || '添加菜单失败');
      throw error;
    }
  },

  // 更新菜单
  async updateMenu(menuData: any): Promise<any> {
    try {
      console.log('更新菜单，参数:', menuData);
      
      const response = await request.put(`${API_PREFIX}${MENU_UPDATE_ENDPOINT}`, menuData);
      
      if (response) {
        console.log('更新菜单成功:', response);
        ElMessage.success('更新菜单成功');
        return response.data;
      } else {
        console.error('更新菜单失败:', response);
        ElMessage.error('更新菜单失败');
        throw new Error('更新菜单接口返回异常');
      }
    } catch (error: any) {
      console.error('更新菜单请求失败:', error);
      ElMessage.error(error.message || '更新菜单失败');
      throw error;
    }
  },

  // 删除菜单
  async deleteMenu(ids: number[]): Promise<any> {
    try {
      console.log('删除菜单，参数:', { id: ids });
      
      const response = await request.delete(`${API_PREFIX}${MENU_DELETE_ENDPOINT}`, { id: ids });
      
      if (response) {
        console.log('删除菜单成功:', response);
        ElMessage.success('删除菜单成功');
        return response.data;
      } else {
        console.error('删除菜单失败:', response);
        ElMessage.error('删除菜单失败');
        throw new Error('删除菜单接口返回异常');
      }
    } catch (error: any) {
      console.error('删除菜单请求失败:', error);
      ElMessage.error(error.message || '删除菜单失败');
      throw error;
    }
  },

  // 处理API返回的数据
  processApiResponseData(apiData: any[]): MenuListType[] {
    try {
      // 检查数据格式
      if (!Array.isArray(apiData)) {
        console.error('API数据不是数组格式');
        throw new Error('API数据格式错误');
      }

      // 转换组件路径字符串为实际路径
      return apiData.map(menuItem => {
        const processedItem = { ...menuItem };
        
        // 处理组件字段，将RoutesAlias字符串转换为实际路径
        if (typeof processedItem.component === 'string') {
          if (processedItem.component.startsWith('RoutesAlias.')) {
            const aliasKey = processedItem.component.replace('RoutesAlias.', '');
            processedItem.component = (RoutesAlias as any)[aliasKey] || '';
          }
        }
        
        // 处理子菜单
        if (Array.isArray(processedItem.children) && processedItem.children.length > 0) {
          processedItem.children = this.processApiResponseData(processedItem.children);
        }
        
        // 确保必要的字段存在
        if (!processedItem.redirect) {
          processedItem.redirect = '';
        }
        
        return processedItem;
      });
    } catch (error) {
      console.error('处理API数据出错:', error);
      throw error;
    }
  },

  // 将嵌套的菜单结构扁平化为一维数组（包含所有子菜单）
  flattenMenusWithChildren(menus: any[]): any[] {
    if (!Array.isArray(menus)) {
      console.warn('flattenMenusWithChildren: 输入不是数组');
      return [];
    }

    let result: any[] = [];
    
    for (const menu of menus) {
      // 添加当前菜单到结果
      result.push({...menu});
      
      // 递归处理子菜单
      if (menu.children && Array.isArray(menu.children) && menu.children.length > 0) {
        const flattenedChildren = this.flattenMenusWithChildren(menu.children);
        result = result.concat(flattenedChildren);
      }
    }
    
    return result;
  },

  // 退出登录，清空localStorage
  logout(): void {
    // 清空localStorage中的所有内容
    localStorage.clear();
    
    // 提示用户已退出登录
    ElMessage.success({
      message: '已成功退出登录',
      type: 'success',
      duration: 2000
    });
  }
}